package 集合;

import java.util.*;

public class Collection {

    private static final Integer NUM = 20000000;
    private static final Integer FIND = 50000;

    public static void main(String[] args) {

//        list();


//        set();


//        map();

    }

    private static void map() {
        //1. hashmap 键值对形式 底层哈希表   特点键不可重复 值可以  线程不安全
        HashMap<String, Integer> hashMap = new HashMap<>();
        //2. hashtable 线程安全 底层  哈希表
        //3. TreeMap  底层二叉树 线程不安全
    }

    private static void set() {
        //        1.hashset 数据结构  底层hashMap 无序不重复
        HashSet<Integer> hashSet = new HashSet<>();
//        2.treeset 底层二叉树
//        3.linkedhashset linkHashMap
    }

    private static void list() {
        //        list 集合
//        1. arraylist    数据结构 数组  线程不安全  特点 有序可重复   查找快  插入麻烦（扩容  扩容机制） 原理 TODO 需要补充原理
        ArrayList<Integer> arrayList = new ArrayList<>();
        // 插入20w 数据 查找从20w查询一个 查看效率
        long begin = System.currentTimeMillis();
        //    2
        // 526  插入
        InsertDate(NUM,arrayList);
        // 12  查找
        arrayList.indexOf(FIND);
        long end = System.currentTimeMillis();
        System.out.println(end - begin);


//     2.linkList  数据结构 双向链表 线程不安全  特点 有序可重复 查找慢（不能通过下表查找 只能通过遍历查找） 插入简单
//        LinkedList<Integer> linkedList = new LinkedList<>();
        // 插入20w 数据 查找从20w查询一个 查看效率
//        long begin = System.currentTimeMillis();
//        //    2
//        // 3001  插入  插入效率相对于数组来说也不是很高 因为每次插入都要创建新节点
//        InsertDate(NUM,linkedList);
//        // 46  查找
//        arrayList.indexOf(FIND);
//        long end = System.currentTimeMillis();
//        System.out.println(end - begin);

//        Vevtor 数据结构 数组 线程安全 特点有序可重复 效率比arraylist低
//        Vector<Integer> vector = new Vector<>();
//        long begin = System.currentTimeMillis();
//        //    2
//        // 718  插入
//        InsertDate(NUM,vector);
//        // 20  查找
//        arrayList.indexOf(FIND);
//        long end = System.currentTimeMillis();
//        System.out.println(end - begin);
    }

    static ArrayList<Integer> arrayList = new ArrayList<>();


    static class myThread extends Thread{
        @Override
        public void run() {
            ArrayList<Integer> arrayList1 = arrayList;
            for (int i = 0; i < 20; i++) {
                arrayList1.add(i);
            }
        }
    }



    public static  <T> void InsertDate(int num, List<T> tf){
        for (int i = 0; i < num; i++) {
            tf.add(covertTo(tf.getClass(),i));
        }
    }

    public static  <R,T> R covertTo(Class<T> type,Integer i){
//        if(type == Integer.class){
//            return (R) i;
//        }
        return (R) i;
    }





    public int incremovableSubarrayCount(int[] nums) {
        //
        int begin = 0;
        int end = 0;

        int count = 0;
        int flag =  1;
        int lastNum = Integer.MIN_VALUE;
        while (begin <= nums.length) {
            if(end == nums.length){
                begin++;
                end = begin;
            }
            flag = 1;
            for (int j = 0; j < nums.length; j++) {
                if(j >= begin && j <= end){
                    continue;
                }
                if(lastNum > nums[j]){
                    flag = 0;
                    break;
                }else{
                    lastNum = nums[j];
                }
            }
            if(flag == 1){
                count++;
            }
            end++;
        }

        return count;
    }




    }







}
